home *** CD-ROM | disk | FTP | other *** search
/ IRIX 6.2 Applications 1996 May / SGI IRIX 6.2 Applications 1996 May.iso / dist / impr_dev.idb / usr / impressario / src / libstiff / stiff.c.z / stiff.c
C/C++ Source or Header  |  1996-05-06  |  6KB  |  286 lines
  1. /*
  2.  * stiff.c
  3.  *
  4.  * stream tiff stuff - mostly public wrappers around the tag stuff;
  5.  * the goal being to insulate the programmer from icky tag stuff as
  6.  * much as possible.
  7.  *
  8.  * Copyright 1993, Silicon Graphics, Inc.
  9.  * All Rights Reserved.
  10.  *
  11.  * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.;
  12.  * the contents of this file may not be disclosed to third parties, copied or
  13.  * duplicated in any form, in whole or in part, without the prior written
  14.  * permission of Silicon Graphics, Inc.
  15.  *
  16.  * RESTRICTED RIGHTS LEGEND:
  17.  * Use, duplication or disclosure by the Government is subject to restrictions
  18.  * as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data
  19.  * and Computer Software clause at DFARS 252.227-7013, and/or in similar or
  20.  * successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished -
  21.  * rights reserved under the Copyright Laws of the United States.
  22.  */
  23.  
  24. #include <sys/types.h>
  25. #include <sys/time.h>
  26.  
  27. #include <unistd.h>
  28. #include <stdio.h>
  29. #include <stdlib.h>
  30. #include <stiff.h>
  31. #include <bstring.h>
  32. #include "stiffp.h"
  33.  
  34. /*
  35.  *  int
  36.  *  STReadImageHeader(STStream *st, STImageHeader *hd)
  37.  *
  38.  *  Description:
  39.  *      Reads the next image header from the stream
  40.  *
  41.  *  Parameters:
  42.  *      st  tiff stream
  43.  *      hd  data structure to receive header information
  44.  *
  45.  *  Returns:
  46.  *      0 if successful, -1 if error
  47.  */
  48.  
  49. int
  50. STReadImageHeader(STStream *st, STImageHeader *hd)
  51. {
  52.     STTagType type;
  53.     unsigned long len, *doffsetp;
  54.     STStream *newStream;
  55.     fd_set fds;
  56.     struct timeval tv;
  57.  
  58.     _STFreeTags(st->tags);
  59.  
  60.     /*
  61.      * If read_tags returns NULL we will assume that there were
  62.      * no tags to read
  63.      */
  64.     if ((st->tags = _STReadTags(st)) == NULL) {
  65.     /*
  66.      * If it's anything other than an end of stream, forget it.
  67.      */
  68.     if (STerrno != STEEOF) {
  69.         return -1;
  70.     }
  71.     /*
  72.      * This allows multiple stiff files to be concatenated
  73.      * together and read in by applications.  We call STOpen to
  74.      * see if there's another stiff "file" beyond this one, and if
  75.      * so, we just keep going.
  76.      */
  77.     FD_ZERO(&fds);
  78.     FD_SET(st->fd, &fds);
  79.     timerclear(&tv);
  80.  
  81.     /*
  82.      * Don't block on a pipe
  83.      */
  84.     if (select(st->fd + 1, &fds, NULL, NULL, &tv) != 1 ||
  85.         !FD_ISSET(st->fd, &fds)) {
  86.         return -1;
  87.     }
  88.  
  89.     newStream = STOpen(st->fd, ST_READ);
  90.     if (newStream == NULL ||
  91.         (newStream->tags = _STReadTags(newStream)) == NULL) {
  92.         if (newStream) {
  93.         free(newStream);
  94.         }
  95.         STerrno = STEEOF;
  96.         return -1;
  97.     }
  98.     *st = *newStream;
  99.     free(newStream);
  100.     }
  101.  
  102.     /*
  103.      * Point to image data.  Use the first one if there are more than
  104.      * one, making the possibly rash assumption that each strip
  105.      * immediately follows the one before it.
  106.      */
  107.     if (_STGetTag(st->tags, STStripOffsets, &type, &len,
  108.           (void**)&doffsetp) < 0) {
  109.     return -1;
  110.     }
  111.  
  112.     if (type != ST_TAG_TYPE_LONG) {
  113.     STerrno = STEBADTAG;
  114.     return -1;
  115.     }
  116.  
  117.     if (STSkipTo(st, *doffsetp) < 0) {
  118.     return -1;
  119.     }
  120.  
  121.     /*
  122.      * fill in the image header
  123.      */
  124.     return _STUntagify(st->tags, hd);
  125. }
  126.  
  127. /*
  128.  *  int
  129.  *  STWriteImageHeader(STStream *st, STImageHeader *hd, int last)
  130.  *
  131.  *  Description:
  132.  *      Writes an image header onto the stream
  133.  *
  134.  *  Parameters:
  135.  *      st    tiff stream
  136.  *      hd    the header to write
  137.  *      last  set to 1 if this is the last image, set to 0 if not
  138.  *
  139.  *  Returns:
  140.  *      0 if successful, -1 if error
  141.  */
  142.  
  143. int
  144. STWriteImageHeader(STStream *st, STImageHeader *hd, int last)
  145. {
  146.     STTagList *tags;
  147.     int status;
  148.  
  149.     tags = _STTagify(st->tags, hd);
  150.     if (!tags) {
  151.     return -1;
  152.     }
  153.  
  154.     status = _STWriteTags(st, tags, last);
  155.  
  156.     _STFreeTags(tags);
  157.  
  158.     /*
  159.      * st->tags were merged in with tags, so now that we've freed tags
  160.      * we need to clobber st->tags.
  161.      */
  162.     st->tags = 0;
  163.  
  164.     return status;
  165. }
  166.  
  167. /*
  168.  *  int
  169.  *  STAddTag(STStream *st, unsigned short tag, STTagType type,
  170.  *        unsigned long len, void *val)
  171.  *
  172.  *  Description:
  173.  *      Add a tag to the stream.  It will get written into the next
  174.  *      image file directory written by STWriteImageHeader().
  175.  *
  176.  *      If there already was a tag with the same "tag" value, it will
  177.  *      get overwritten.
  178.  *
  179.  *  Parameters:
  180.  *      st    tiff stream
  181.  *      tag   tag to write
  182.  *      type  type of tag
  183.  *      len   length of data
  184.  *      val   pointer to the data
  185.  *
  186.  *  Returns:
  187.  *      0 if successful, -1 if error
  188.  */
  189.  
  190. int
  191. STAddTag(STStream *st, unsigned short tag, STTagType type,
  192.                     unsigned long len, void *val)
  193. {
  194.     STTagList *tmp;
  195.  
  196.     tmp = _STInsertTag(st->tags, tag, type, len, val);
  197.  
  198.     if (!tmp) {
  199.     return -1;
  200.     }
  201.  
  202.     st->tags = tmp;
  203.     return 0;
  204. }
  205.  
  206. /*
  207.  *  int
  208.  *  STRemoveTag(STStream *st, unsigned short tag)
  209.  *
  210.  *  Description:
  211.  *      Removes a tag from the tags that will be written next time
  212.  *      STWriteImageHeader() is called.
  213.  *
  214.  *  Parameters:
  215.  *      st   tiff stream
  216.  *      tag  tag to remove
  217.  *
  218.  *  Returns:
  219.  *      0 if successful, -1 if error
  220.  */
  221.  
  222. int
  223. STRemoveTag(STStream *st, unsigned short tag)
  224. {
  225.     STTagList *tmp;
  226.  
  227.     if (_STDeleteTag(st->tags, tag, &tmp) == -1) {
  228.     return -1;
  229.     }
  230.  
  231.     st->tags = tmp;
  232.     return 0;
  233. }
  234.  
  235. /*
  236.  *  int
  237.  *  STGetTag(STStream *st, unsigned short tag, STTagType *type,
  238.  *           unsigned long *len, void **val)
  239.  *
  240.  *  Description:
  241.  *      Get the value of a tag that has been added to st, either by
  242.  *      being read from the stream or by a call to STAddTag().
  243.  *
  244.  *  Parameters:
  245.  *      st    tiff stream
  246.  *      tag   tag to get
  247.  *      type  receives type of tag
  248.  *      len   receives length of tag
  249.  *      valp  receives tag data.  If more than can fit in 4 bytes,
  250.  *            this will be a pointer into memory owned by the tags
  251.  *            module, so don't muck with it!!!  And don't assume that
  252.  *            it will be meaningful after a subsequent call to
  253.  *            STReadImageHeader!!! If you want to preserve the value,
  254.  *          copy it to your space.
  255.  *
  256.  *  Returns:
  257.  *      0 if successful, -1 if error.
  258.  */
  259.  
  260. int
  261. STGetTag(STStream *st, unsigned short tag, STTagType *type,
  262.      unsigned long *len, void **valp)
  263. {
  264.     return _STGetTag(st->tags, tag, type, len, valp);
  265. }
  266.  
  267. /*
  268.  *  int
  269.  *  STPrintTags(STStream *st)
  270.  *
  271.  *  Description:
  272.  *      st->tags
  273.  *
  274.  *  Parameters:
  275.  *      st  tiff stream to print tags of
  276.  *
  277.  *  Returns:
  278.  *      0 if successful, -1 if error
  279.  */
  280.  
  281. int
  282. STPrintTags(FILE *fp, STStream *st)
  283. {
  284.     return _STPrintTags(fp, st->tags);
  285. }
  286.